{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "34qVD_ntSKLF"
   },
   "source": [
    "# Cvxpylayers + Neuromancer\n",
    "\n",
    "\n",
    "This example demonstrates integration of Cvxpylayers into Neuromancer.\n",
    "We will demonstrate this capability on learning to optimize\n",
    "for [parametric nonlinear programming problem (pNLP)](https://en.wikipedia.org/wiki/Parametric_programming) defined as:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "&\\text{minimize } &&  f(x, \\theta) \\\\\n",
    "&\\text{subject to} && g(x, \\theta) \\le 0\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "with  parameters $\\theta$ and decision variables $x$.\n",
    "\n",
    "\n",
    "### Cvxpy Layes References\n",
    "[1] [Agrawal, A. and Amos, B. and Barratt, S. and Boyd, S. and Diamond, S. and Kolter, Z., Differentiable Convex Optimization Layers, NeurIPS 2019](https://arxiv.org/abs/1910.12430)  \n",
    "[2] https://github.com/cvxgrp/cvxpylayers/tree/master  \n",
    "[3] https://locuslab.github.io/2019-10-28-cvxpylayers/  \n",
    "\n",
    "### Learning to Optimize References\n",
    "[1] [F. Fioretto, et al., Predicting AC Optimal Power Flows: Combining Deep Learning and Lagrangian Dual Methods, 2019](https://arxiv.org/abs/1909.10461)  \n",
    "[2] [S. Gould, et al., Deep Declarative Networks: A New Hope, 2020](https://arxiv.org/abs/1909.04866)  \n",
    "[3] [P. Donti, et al., DC3: A learning method for optimization with hard constraints, 2021](https://arxiv.org/abs/2104.12225)  \n",
    "[4] [J. Kotary, et al., End-to-End Constrained Optimization Learning: A Survey, 2021](https://arxiv.org/abs/2103.16378)  \n",
    "[5] [M. Li, et al., Learning to Solve Optimization Problems with Hard Linear Constraints, 2022](https://arxiv.org/abs/2208.10611)  \n",
    "[6] [R. Sambharya, et al., End-to-End Learning to Warm-Start for Real-Time Quadratic Optimization, 2022](https://arxiv.org/abs/2212.08260)  \n",
    "[7] [Parametric programming in Neuromancer](https://github.com/pnnl/neuromancer/tree/master/examples/parametric_programming)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "OCn3zpaIqgMc"
   },
   "source": [
    "## NeuroMANCER and Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Qzy5Wot5k2Gf"
   },
   "source": [
    "### Install (Colab only)\n",
    "Skip this step when running locally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "X_3EvkSz0Fnz",
    "outputId": "23c06f6b-ab48-4763-c43c-40a325cacf87"
   },
   "outputs": [],
   "source": [
    "!pip install neuromancer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: When running on Colab, one might encounter a pip dependency error with Lida 0.0.10. This can be ignored*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LWyvndXlz0Fv"
   },
   "source": [
    "### Import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "KbP0n-4evRqt"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import cvxpy\n",
    "from cvxpylayers.torch import CvxpyLayer\n",
    "\n",
    "# plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patheffects as patheffects\n",
    "\n",
    "# neuromancer\n",
    "from neuromancer.trainer import Trainer\n",
    "from neuromancer.problem import Problem\n",
    "from neuromancer.constraint import variable\n",
    "from neuromancer.dataset import DictDataset\n",
    "from neuromancer.loss import PenaltyLoss\n",
    "from neuromancer.modules import blocks\n",
    "from neuromancer.system import Node"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem Formulation\n",
    "\n",
    "Specifically we will focus on solving the [Rosenbrock problem](https://en.wikipedia.org/wiki/Rosenbrock_function):\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "&\\text{minimize } &&  (1-x_1)^2 + p(x_2-x_1^2)^2\\\\\n",
    "&\\text{subject to} && Ax \\le b\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "with parameters $p, b$ and decision variables $x= [x_1, x_2]$.\n",
    "\n",
    "In this tutorial, we will use neuromancer to train the neural network to minimize the nonlinear objective function,\n",
    "and cvxpy layers to project the solution onto feasible region."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx = 2              #  number of decision variables\n",
    "n_con = 4           #  number of constraints\n",
    "n_p = 1             #  number of objective parameters\n",
    "\n",
    "# generate fixed parameters of the inequality constraints: Ax <= b\n",
    "torch.manual_seed(7)\n",
    "A = torch.FloatTensor(n_con, nx).uniform_(-4, 4)\n",
    "x0 = torch.full([nx], 0.5)       # controls center of the polytope\n",
    "s0 = torch.full([n_con], 0.2)    # controls offset from the center of the polytope\n",
    "b0 = A.mv(x0) + s0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_WH7o7Wu1epw"
   },
   "source": [
    "## Dataset\n",
    "\n",
    "We constructy the dataset by sampling the parametric space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "_r6p2p6myHAh"
   },
   "outputs": [],
   "source": [
    "data_seed = 408  # random seed used for simulated data\n",
    "np.random.seed(data_seed)\n",
    "torch.manual_seed(data_seed);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JZ9qrw0tlJhs"
   },
   "source": [
    "Randomly sample parameters from a uniform distribution: $0.5\\le p\\le5.0$;  $0.0\\le b\\le1.0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "Nu58M-8JyHy6"
   },
   "outputs": [],
   "source": [
    "nsim = 1000  # number of datapoints: increase sample density for more robust results\n",
    "# create dictionaries with sampled datapoints with uniform distribution\n",
    "p_low, p_high = 0.2, 5.0,\n",
    "b_low, b_high = 0.0, 1.0,\n",
    "# we sample objective and constraints parameters\n",
    "samples_train = {\"p\": torch.FloatTensor(nsim, n_p).uniform_(p_low, p_high),\n",
    "                 \"b_param\": torch.FloatTensor(nsim, n_con).uniform_(b_low, b_high)}\n",
    "samples_dev = {\"p\": torch.FloatTensor(nsim, n_p).uniform_(p_low, p_high),\n",
    "               \"b_param\": torch.FloatTensor(nsim, n_con).uniform_(b_low, b_high)}\n",
    "samples_test = {\"p\": torch.FloatTensor(nsim, n_p).uniform_(p_low, p_high),\n",
    "                \"b_param\": torch.FloatTensor(nsim, n_con).uniform_(b_low, b_high)}\n",
    "# create named dictionary datasets\n",
    "train_data = DictDataset(samples_train, name='train')\n",
    "dev_data = DictDataset(samples_dev, name='dev')\n",
    "test_data = DictDataset(samples_test, name='test')\n",
    "# create torch dataloaders for the Trainer\n",
    "train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, num_workers=0,\n",
    "                                           collate_fn=train_data.collate_fn, shuffle=True)\n",
    "dev_loader = torch.utils.data.DataLoader(dev_data, batch_size=32, num_workers=0,\n",
    "                                         collate_fn=dev_data.collate_fn, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_data, batch_size=32, num_workers=0,\n",
    "                                         collate_fn=test_data.collate_fn, shuffle=True)\n",
    "# note: training quality will depend on the DataLoader parameters such as batch size and shuffle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Y2htUaWMDjsk"
   },
   "source": [
    "## Primal Solution Map Architecture\n",
    "\n",
    "A neural network mapping problem parameters onto primal decision variables:  \n",
    "$$x = \\pi(\\theta)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Ta_I_pjyyLzf"
   },
   "outputs": [],
   "source": [
    "# define neural architecture for the trainable solution map\n",
    "# mapping problem parameters to decision variables\n",
    "func = blocks.MLP(insize=n_con+n_p, outsize=nx,\n",
    "                bias=True,\n",
    "                linear_map=torch.nn.Linear,\n",
    "                nonlin=nn.ReLU,\n",
    "                hsizes=[80] * 4)\n",
    "# wrap neural net into symbolic representation of the solution map via the Node class:\n",
    "# sol_map(p, bparam) -> xy\n",
    "sol_map = Node(func, ['p', 'b_param'], ['xy'], name='map')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Lxj77EFj7EO-"
   },
   "source": [
    "## Objective in NeuroMANCER\n",
    "\n",
    "\n",
    "We want to minimize the objective:\n",
    "$$\n",
    "\\begin{align}\n",
    "&\\text{minimize } &&  (1-x_1)^2 + p(x_2-x_1^2)^2\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "with $x = [x_1, x_2]$ being decision variables and $p$ being problem parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "bcoVjphjyPp9"
   },
   "outputs": [],
   "source": [
    "# define decision variables\n",
    "xy = variable(\"xy\")\n",
    "x = variable(\"xy\")[:, [0]]\n",
    "y = variable(\"xy\")[:, [1]]\n",
    "# problem parameters sampled in the dataset\n",
    "p = variable('p')\n",
    "b_param = variable('b_param')\n",
    "\n",
    "# objective function\n",
    "f = (1-x)**2 + p*(y-x**2)**2\n",
    "nm_obj = f.minimize(weight=10.0, name='obj')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cvxpy projection layer\n",
    "\n",
    "We will use cvxpy layer to implement the projection onto the polytopic constraints:\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "& \\hat{x}  = \\text{argmin}_x && ||x -  \\hat{x}  ||_2^2 \\\\\n",
    "&\\text{subject to} && A \\hat{x} \\le b\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "with $x$ being solution obtained from the neural network $x = \\pi(\\theta)$, and $\\hat{x}$ being projected solution onto the feasible set satisfying $A \\hat{x} \\le b$. Here the problem constraints are parametrized by $b$ and solution from neural network $x$. Hence we can compactly represent this projection operator as:  \n",
    "\n",
    "$$\\hat{x} = \\text{proj}_{A x \\le b}(x, b) $$\n",
    "\n",
    "Cvxpy layers allow us to use this projection operator as a differentiable layer in our end-to-end solver pipeline.\n",
    "\n",
    "\n",
    "<img src=\"./figs/cvxpylayers_overview.png\" width=\"600\">  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# constants, parameters, and variables\n",
    "A_cvxpy = A.detach().numpy()\n",
    "b0_cvxpy = b0.detach().numpy()\n",
    "b_cvxpy = cvxpy.Parameter(n_con)\n",
    "xy_net = cvxpy.Parameter(nx)      # primal decision from neural net\n",
    "xy_cvxpy = cvxpy.Variable(nx)     # cvxpy decision variable\n",
    "\n",
    "# projection problem formulation\n",
    "cvxpy_obj = cvxpy.Minimize(1.0 * cvxpy.sum_squares(xy_net - xy_cvxpy))\n",
    "cvxpy_cons = [xy_cvxpy@A_cvxpy.T <= b0_cvxpy + b_cvxpy]\n",
    "cvxpy_prob = cvxpy.Problem(cvxpy_obj, cvxpy_cons)\n",
    "\n",
    "# cvxpy layer\n",
    "cvxpy_layer = CvxpyLayer(cvxpy_prob,\n",
    "                   parameters=[b_cvxpy, xy_net],\n",
    "                   variables=[xy_cvxpy])\n",
    "\n",
    "# symbolic wrapper: sol_map(bparam, xy) -> xy\n",
    "project = Node(cvxpy_layer, ['b_param', 'xy'], ['xy_cvx'], name='proj')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-supervised loss\n",
    "\n",
    "We can use the correction form the cvxpylayer as a supervisory signal for the neural network alongside with the objective minimization loss function term. This extra term can be used as a guide for the neural network to satisfy constraints of the problem by following the projected solution. The larger the weigthing factor of this loss function term the closer the neural network will be to feasible region on its own without the subsequent projection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# corrected variable by the cvxpy layer\n",
    "xy_cvx = variable(\"xy_cvx\")\n",
    "# cvxpy-supervised loss for the neural net\n",
    "residual = torch.abs(xy - xy_cvx)\n",
    "cvxp_loss = 1.*(residual == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construct differentiable parametric optimization problem \n",
    "\n",
    "Here we put all the pieces together and construct differentiable parametric constrained optimization problem with neural network and cvxpy projection layer as solvers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 496
    },
    "id": "n7VPa9Wc8JRB",
    "outputId": "0da17c45-6370-4f46-f626-bd5686b94bfc"
   },
   "outputs": [],
   "source": [
    "# constrained optimization problem construction\n",
    "objectives = [nm_obj, cvxp_loss]\n",
    "constraints = []\n",
    "nodes = [sol_map, project]\n",
    "\n",
    "# create penalty method loss function\n",
    "loss = PenaltyLoss(objectives, constraints)\n",
    "# construct constrained optimization problem\n",
    "problem = Problem(nodes, loss)\n",
    "# plot computational graph\n",
    "# problem.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "icWSMeG28SKc"
   },
   "source": [
    "## Parametric Problem Solution in NeuroMANCER\n",
    "\n",
    "Here we will use stochastic gradient descent to optimize the neural network $x = \\pi({\\theta})$ to solve a distribution of sampled problem instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "rk1bRczByUvl"
   },
   "outputs": [],
   "source": [
    "lr = 0.001      # step size for gradient descent\n",
    "epochs = 10    # number of training epochs\n",
    "warmup = 10    # number of epochs to wait before enacting early stopping policy\n",
    "patience = 10  # number of epochs with no improvement in eval metric to allow before early stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "x4oS2N2ZyWtD"
   },
   "outputs": [],
   "source": [
    "optimizer = torch.optim.AdamW(problem.parameters(), lr=lr)\n",
    "# define trainer\n",
    "trainer = Trainer(\n",
    "    problem,\n",
    "    train_loader,\n",
    "    dev_loader,\n",
    "    test_loader,\n",
    "    optimizer,\n",
    "    epochs=epochs,\n",
    "    patience=patience,\n",
    "    warmup=warmup,\n",
    "    train_metric=\"train_loss\",\n",
    "    dev_metric=\"dev_loss\",\n",
    "    test_metric=\"test_loss\",\n",
    "    eval_metric=\"dev_loss\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "27ASQD3q-M0A",
    "outputId": "04eec20c-51c3-4a71-e570-9636af9421c0"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\drgo694\\OneDrive - PNNL\\Documents\\anaconda3\\envs\\neuromancer\\lib\\site-packages\\threadpoolctl.py:1010: RuntimeWarning: \n",
      "Found Intel OpenMP ('libiomp') and LLVM OpenMP ('libomp') loaded at\n",
      "the same time. Both libraries are known to be incompatible and this\n",
      "can cause random crashes or deadlocks on Linux when loaded in the\n",
      "same Python program.\n",
      "Using threadpoolctl may cause crashes or deadlocks. For more\n",
      "information and possible workarounds, please see\n",
      "    https://github.com/joblib/threadpoolctl/blob/master/multiple_openmp.md\n",
      "\n",
      "  warnings.warn(msg, RuntimeWarning)\n",
      "C:\\Users\\drgo694\\OneDrive - PNNL\\Documents\\Codes_dev\\neuromancer\\neuromancer\\src\\neuromancer\\constraint.py:160: UserWarning: Using a target size (torch.Size([])) that is different to the input size (torch.Size([32, 2])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  loss = F.l1_loss(left, right)\n",
      "C:\\Users\\drgo694\\OneDrive - PNNL\\Documents\\Codes_dev\\neuromancer\\neuromancer\\src\\neuromancer\\constraint.py:160: UserWarning: Using a target size (torch.Size([])) that is different to the input size (torch.Size([8, 2])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.\n",
      "  loss = F.l1_loss(left, right)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0  train_loss: 3.2589499950408936\n",
      "epoch: 1  train_loss: 0.3854714632034302\n",
      "epoch: 2  train_loss: 0.23118728399276733\n",
      "epoch: 3  train_loss: 0.19490081071853638\n",
      "epoch: 4  train_loss: 0.18166562914848328\n",
      "epoch: 5  train_loss: 0.17738522589206696\n",
      "epoch: 6  train_loss: 0.17531158030033112\n",
      "epoch: 7  train_loss: 0.1747892051935196\n",
      "epoch: 8  train_loss: 0.17444592714309692\n",
      "epoch: 9  train_loss: 0.17344167828559875\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train NLP solution map\n",
    "best_model = trainer.train()\n",
    "best_outputs = trainer.test(best_model)\n",
    "# load best model dict\n",
    "problem.load_state_dict(best_model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0hhUw4PVBWmb"
   },
   "source": [
    "## Plot the solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 281
    },
    "id": "kvYCfjq6zxxC",
    "outputId": "322e5b72-b93d-4d9e-a913-8703aad67d1a"
   },
   "outputs": [],
   "source": [
    "def plot_pNLP(p, b_param, savedir=None):\n",
    "    # sample primal solution domain\n",
    "    x1 = np.arange(-0.5, 1.5, 0.02)\n",
    "    y1 = np.arange(-0.5, 1.5, 0.02)\n",
    "    xx, yy = np.meshgrid(x1, y1)\n",
    "    xy_samples = np.stack([xx.flatten(), yy.flatten()])\n",
    "\n",
    "    # eval constraints Ax - b <= 0\n",
    "    A_np = A.detach().numpy()\n",
    "    b = b0 + b_param\n",
    "    b_np = b.detach().numpy()\n",
    "    C_samples = np.subtract(np.matmul(A_np, xy_samples).T, b_np).T\n",
    "    C_samples = C_samples.reshape(n_con, x1.shape[0], y1.shape[0])\n",
    "\n",
    "    # eval objective\n",
    "    p_np = p.detach().numpy()\n",
    "    J = (1 - xx) ** 2 + p_np * (yy - xx ** 2) ** 2\n",
    "\n",
    "    # plot objective and constraints\n",
    "    fig, ax = plt.subplots(1, 1)\n",
    "    cp = ax.contourf(xx, yy, J,\n",
    "                     levels=[0, 0.05, 0.2, 0.5, 1.0, 2.0, 4.0, 6.0, 8.0, 16],\n",
    "                     alpha=0.6)\n",
    "    fig.colorbar(cp)\n",
    "    ax.set_title('Rosenbrock problem')\n",
    "    for k in range(n_con):\n",
    "        cg1 = ax.contour(xx, yy, -C_samples[k], [0],\n",
    "                         colors='mediumblue', alpha=0.7)\n",
    "        if hasattr(cg1, 'collections') and cg1.collections:\n",
    "            plt.setp(cg1.collections,\n",
    "                 path_effects=[patheffects.withTickedStroke()], alpha=0.7)\n",
    "\n",
    "\n",
    "    # Solution to pNLP via Neuromancer\n",
    "    datapoint = {'p': p, 'b_param': b_param,\n",
    "                 'name': 'test'}\n",
    "    # evaluate neuromancer model\n",
    "    model_out = problem.step(datapoint)\n",
    "    # neural net solution\n",
    "    x_nm_net = model_out[\"xy\"][0].detach().numpy()\n",
    "    y_nm_net = model_out[\"xy\"][1].detach().numpy()\n",
    "    # cvxpy projected solution\n",
    "    x_nm_cvx = model_out[\"xy_cvx\"][0].detach().numpy()\n",
    "    y_nm_cvx = model_out[\"xy_cvx\"][1].detach().numpy()\n",
    "\n",
    "    # plot optimal solutions CasADi vs Neuromancer\n",
    "    ax.plot(x_nm_net, y_nm_net, 'r*', fillstyle='none',\n",
    "            markersize=16, label='net')\n",
    "    ax.plot(x_nm_cvx, y_nm_cvx, 'g*', fillstyle='none',\n",
    "            markersize=14, label='cvxpy')\n",
    "    # plot projection step\n",
    "    ax.plot([x_nm_net, x_nm_cvx],\n",
    "            [y_nm_net, y_nm_cvx], '--', c='orange')\n",
    "    plt.legend(bbox_to_anchor=(1.0, 0.15))\n",
    "\n",
    "    if savedir is not None:\n",
    "        if not os.path.exists(savedir):\n",
    "            os.mkdir(savedir)\n",
    "        figure_path = os.path.join(savedir, f'pNLP_p={p}_bsum={b_np}.png')\n",
    "        plt.savefig(figure_path)\n",
    "        return figure_path\n",
    "    else:\n",
    "        plt.show(block=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "yD5kAnjy4CUL"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# sample random scenario\n",
    "p = torch.FloatTensor(n_p).uniform_(p_low, p_high)\n",
    "b_param = torch.rand(n_con)\n",
    "# plot single random scenario\n",
    "plot_pNLP(p, b_param)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "neuromancer",
   "language": "python",
   "name": "neuromancer"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
